home *** CD-ROM | disk | FTP | other *** search
/ Chip 2000 October / CHIP Turkiye Ekim 2000.iso / prog / naps / 04 / setup.exe / Gnucleus / HyperLink.cpp < prev    next >
C/C++ Source or Header  |  2000-06-17  |  15KB  |  495 lines
  1. // HyperLink.cpp : implementation file
  2. //
  3. // HyperLink static control. Will open the default browser with the given URL
  4. // when the user clicks on the link.
  5. //
  6. // Copyright (C) 1997 - 1999 Chris Maunder
  7. // All rights reserved. May not be sold for profit.
  8. //
  9. // Thanks to Pσl K. T°nder for auto-size and window caption changes.
  10. //
  11. // "GotoURL" function by Stuart Patterson
  12. // As seen in the August, 1997 Windows Developer's Journal.
  13. // Copyright 1997 by Miller Freeman, Inc. All rights reserved.
  14. // Modified by Chris Maunder to use TCHARs instead of chars.
  15. //
  16. // "Default hand cursor" from Paul DiLascia's Jan 1998 MSJ article.
  17. //
  18. // 2/29/00 -- P. Shaffer standard font mod.
  19.  
  20. #include "stdafx.h"
  21. #include "HyperLink.h"
  22.  
  23. #include "atlconv.h"    // for Unicode conversion - requires #include <afxdisp.h> // MFC OLE automation classes
  24.  
  25. #ifdef _DEBUG
  26. #define new DEBUG_NEW
  27. #undef THIS_FILE
  28. static char THIS_FILE[] = __FILE__;
  29. #endif
  30.  
  31. #define TOOLTIP_ID 1
  32.  
  33. /////////////////////////////////////////////////////////////////////////////
  34. // CHyperLink
  35.  
  36. CHyperLink::CHyperLink()
  37. {
  38.     m_hLinkCursor       = NULL;                 // No cursor as yet
  39.     m_crLinkColour      = RGB(  0,   0, 238);   // Blue
  40.     m_crVisitedColour   = RGB( 85,  26, 139);   // Purple
  41.     m_crHoverColour     = RGB(255,   0,   0);   // Red
  42.     m_bOverControl      = FALSE;                // Cursor not yet over control
  43.     m_bVisited          = FALSE;                // Hasn't been visited yet.
  44.     m_nUnderline        = ulHover;              // Underline the link?
  45.     m_bAdjustToFit      = TRUE;                 // Resize the window to fit the text?
  46.     m_strURL.Empty();
  47.     m_nTimerID          = 100;
  48. }
  49.  
  50. CHyperLink::~CHyperLink()
  51. {
  52.     m_UnderlineFont.DeleteObject();
  53. }
  54.  
  55. /////////////////////////////////////////////////////////////////////////////
  56. // CHyperLink overrides
  57.  
  58. BOOL CHyperLink::DestroyWindow() 
  59. {
  60.     KillTimer(m_nTimerID);
  61.     
  62.     return CStatic::DestroyWindow();
  63. }
  64.  
  65. BOOL CHyperLink::PreTranslateMessage(MSG* pMsg) 
  66. {
  67.     m_ToolTip.RelayEvent(pMsg);
  68.     return CStatic::PreTranslateMessage(pMsg);
  69. }
  70.  
  71.  
  72. void CHyperLink::PreSubclassWindow() 
  73. {
  74.     // We want to get mouse clicks via STN_CLICKED
  75.     DWORD dwStyle = GetStyle();
  76.     ::SetWindowLong(GetSafeHwnd(), GWL_STYLE, dwStyle | SS_NOTIFY);
  77.     
  78.     // Set the URL as the window text
  79.     if (m_strURL.IsEmpty())
  80.         GetWindowText(m_strURL);
  81.  
  82.     // Check that the window text isn't empty. If it is, set it as the URL.
  83.     CString strWndText;
  84.     GetWindowText(strWndText);
  85.     if (strWndText.IsEmpty()) 
  86.     {
  87.         ASSERT(!m_strURL.IsEmpty());    // Window and URL both NULL. DUH!
  88.         SetWindowText(m_strURL);
  89.     }
  90.  
  91.     CFont* pFont = GetFont();
  92.     if (!pFont)
  93.     {
  94.         HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
  95.         if (hFont == NULL)
  96.             hFont = (HFONT) GetStockObject(ANSI_VAR_FONT);
  97.         if (hFont)
  98.             pFont = CFont::FromHandle(hFont);
  99.     }
  100.     ASSERT(pFont->GetSafeHandle());
  101.  
  102.     // Create the underline font
  103.     LOGFONT lf;
  104.     pFont->GetLogFont(&lf);
  105.     m_StdFont.CreateFontIndirect(&lf);
  106.     lf.lfUnderline = (BYTE) TRUE;
  107.     m_UnderlineFont.CreateFontIndirect(&lf);
  108.  
  109.     PositionWindow();        // Adjust size of window to fit URL if necessary
  110.     SetDefaultCursor();      // Try and load up a "hand" cursor
  111.     SetUnderline();
  112.  
  113.     // Create the tooltip
  114.     CRect rect; 
  115.     GetClientRect(rect);
  116.     m_ToolTip.Create(this);
  117.     m_ToolTip.AddTool(this, m_strURL, rect, TOOLTIP_ID);
  118.  
  119.     CStatic::PreSubclassWindow();
  120. }
  121.  
  122. BEGIN_MESSAGE_MAP(CHyperLink, CStatic)
  123.     //{{AFX_MSG_MAP(CHyperLink)
  124.     ON_WM_CTLCOLOR_REFLECT()
  125.     ON_WM_SETCURSOR()
  126.     ON_WM_MOUSEMOVE()
  127.     ON_WM_TIMER()
  128.     ON_CONTROL_REFLECT(STN_CLICKED, OnClicked)
  129.     ON_WM_ERASEBKGND()
  130.     //}}AFX_MSG_MAP
  131. END_MESSAGE_MAP()
  132.  
  133. /////////////////////////////////////////////////////////////////////////////
  134. // CHyperLink message handlers
  135.  
  136. void CHyperLink::OnClicked()
  137. {
  138.     m_bOverControl = FALSE;
  139.     int result = (int)GotoURL(m_strURL, SW_SHOW);
  140.     m_bVisited = (result > HINSTANCE_ERROR);
  141.     if (!m_bVisited)
  142.     {
  143.         MessageBeep(MB_ICONEXCLAMATION);     // Unable to follow link
  144.         ReportError(result);
  145.     }
  146.     else 
  147.         SetVisited();                        // Repaint to show visited colour
  148. }
  149.  
  150. HBRUSH CHyperLink::CtlColor(CDC* pDC, UINT nCtlColor) 
  151. {
  152.     ASSERT(nCtlColor == CTLCOLOR_STATIC);
  153.  
  154.     if (m_bOverControl)
  155.         pDC->SetTextColor(m_crHoverColour);
  156.     else if (m_bVisited)
  157.         pDC->SetTextColor(m_crVisitedColour);
  158.     else
  159.         pDC->SetTextColor(m_crLinkColour);
  160.  
  161.     // transparent text.
  162.     pDC->SetBkMode(TRANSPARENT);
  163.     return (HBRUSH)GetStockObject(NULL_BRUSH);
  164. }
  165.  
  166. void CHyperLink::OnMouseMove(UINT nFlags, CPoint point) 
  167. {
  168.     if (!m_bOverControl)        // Cursor has just moved over control
  169.     {
  170.         m_bOverControl = TRUE;
  171.  
  172.         if (m_nUnderline == ulHover)
  173.             SetFont(&m_UnderlineFont);
  174.         Invalidate();
  175.  
  176.         SetTimer(m_nTimerID, 100, NULL);
  177.     }
  178.     CStatic::OnMouseMove(nFlags, point);
  179. }
  180.  
  181. void CHyperLink::OnTimer(UINT nIDEvent) 
  182. {
  183.     CPoint p(GetMessagePos());
  184.     ScreenToClient(&p);
  185.  
  186.     CRect rect;
  187.     GetClientRect(rect);
  188.     if (!rect.PtInRect(p))
  189.     {
  190.         m_bOverControl = FALSE;
  191.         KillTimer(m_nTimerID);
  192.  
  193.         if (m_nUnderline != ulAlways)
  194.             SetFont(&m_StdFont);
  195.         rect.bottom+=10;
  196.         InvalidateRect(rect);
  197.     }
  198.     
  199.     CStatic::OnTimer(nIDEvent);
  200. }
  201.  
  202. BOOL CHyperLink::OnSetCursor(CWnd* /*pWnd*/, UINT /*nHitTest*/, UINT /*message*/) 
  203. {
  204.     if (m_hLinkCursor)
  205.     {
  206.         ::SetCursor(m_hLinkCursor);
  207.         return TRUE;
  208.     }
  209.     return FALSE;
  210. }
  211.  
  212. BOOL CHyperLink::OnEraseBkgnd(CDC* pDC) 
  213. {
  214.     CRect rect;
  215.     GetClientRect(rect);
  216.     pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DFACE));
  217.  
  218.     return TRUE;
  219. }
  220.  
  221. /////////////////////////////////////////////////////////////////////////////
  222. // CHyperLink operations
  223.  
  224. void CHyperLink::SetURL(CString strURL)
  225. {
  226.     m_strURL = strURL;
  227.  
  228.     if (::IsWindow(GetSafeHwnd())) {
  229.         PositionWindow();
  230.         m_ToolTip.UpdateTipText(strURL, this, TOOLTIP_ID);
  231.     }
  232. }
  233.  
  234. CString CHyperLink::GetURL() const
  235. { 
  236.     return m_strURL;   
  237. }
  238.  
  239. void CHyperLink::SetColours(COLORREF crLinkColour, COLORREF crVisitedColour,
  240.                             COLORREF crHoverColour /* = -1 */) 
  241. { 
  242.     m_crLinkColour    = crLinkColour; 
  243.     m_crVisitedColour = crVisitedColour;
  244.  
  245.     if (crHoverColour == -1)
  246.         m_crHoverColour = ::GetSysColor(COLOR_HIGHLIGHT);
  247.     else
  248.         m_crHoverColour = crHoverColour;
  249.  
  250.     if (::IsWindow(m_hWnd))
  251.         Invalidate(); 
  252. }
  253.  
  254. COLORREF CHyperLink::GetLinkColour() const
  255. { 
  256.     return m_crLinkColour; 
  257. }
  258.  
  259. COLORREF CHyperLink::GetVisitedColour() const
  260. {
  261.     return m_crVisitedColour; 
  262. }
  263.  
  264. COLORREF CHyperLink::GetHoverColour() const
  265. {
  266.     return m_crHoverColour;
  267. }
  268.  
  269. void CHyperLink::SetVisited(BOOL bVisited /* = TRUE */) 
  270. { 
  271.     m_bVisited = bVisited; 
  272.  
  273.     if (::IsWindow(GetSafeHwnd()))
  274.         Invalidate(); 
  275. }
  276.  
  277. BOOL CHyperLink::GetVisited() const
  278. { 
  279.     return m_bVisited; 
  280. }
  281.  
  282. void CHyperLink::SetLinkCursor(HCURSOR hCursor)
  283. { 
  284.     m_hLinkCursor = hCursor;
  285.     if (m_hLinkCursor == NULL)
  286.         SetDefaultCursor();
  287. }
  288.  
  289. HCURSOR CHyperLink::GetLinkCursor() const
  290. {
  291.     return m_hLinkCursor;
  292. }
  293.  
  294. void CHyperLink::SetUnderline(int nUnderline /*=ulHover*/)
  295. {
  296.     if (m_nUnderline == nUnderline)
  297.         return;
  298.  
  299.     if (::IsWindow(GetSafeHwnd()))
  300.     {
  301.         if (nUnderline == ulAlways)
  302.             SetFont(&m_UnderlineFont);
  303.         else
  304.             SetFont(&m_StdFont);
  305.  
  306.         Invalidate(); 
  307.     }
  308.  
  309.     m_nUnderline = nUnderline;
  310. }
  311.  
  312. int CHyperLink::GetUnderline() const
  313. { 
  314.     return m_nUnderline; 
  315. }
  316.  
  317. void CHyperLink::SetAutoSize(BOOL bAutoSize /* = TRUE */)
  318. {
  319.     m_bAdjustToFit = bAutoSize;
  320.  
  321.     if (::IsWindow(GetSafeHwnd()))
  322.         PositionWindow();
  323. }
  324.  
  325. BOOL CHyperLink::GetAutoSize() const
  326. { 
  327.     return m_bAdjustToFit; 
  328. }
  329.  
  330.  
  331. // Move and resize the window so that the window is the same size
  332. // as the hyperlink text. This stops the hyperlink cursor being active
  333. // when it is not directly over the text. If the text is left justified
  334. // then the window is merely shrunk, but if it is centred or right
  335. // justified then the window will have to be moved as well.
  336. //
  337. // Suggested by Pσl K. T°nder 
  338.  
  339. void CHyperLink::PositionWindow()
  340. {
  341.     if (!::IsWindow(GetSafeHwnd()) || !m_bAdjustToFit) 
  342.         return;
  343.  
  344.     // Get the current window position
  345.     CRect WndRect, ClientRect;
  346.     GetWindowRect(WndRect);
  347.     GetClientRect(ClientRect);
  348.  
  349.     ClientToScreen(ClientRect);
  350.  
  351.     CWnd* pParent = GetParent();
  352.     if (pParent)
  353.     {
  354.         pParent->ScreenToClient(WndRect);
  355.         pParent->ScreenToClient(ClientRect);
  356.     }
  357.  
  358.     // Get the size of the window text
  359.     CString strWndText;
  360.     GetWindowText(strWndText);
  361.  
  362.     CDC* pDC = GetDC();
  363.     CFont* pOldFont = pDC->SelectObject(&m_UnderlineFont);
  364.     CSize Extent = pDC->GetTextExtent(strWndText);
  365.     pDC->SelectObject(pOldFont);
  366.     ReleaseDC(pDC);
  367.  
  368.     // Adjust for window borders
  369.     Extent.cx += WndRect.Width() - ClientRect.Width(); 
  370.     Extent.cy += WndRect.Height() - ClientRect.Height(); 
  371.  
  372.     // Get the text justification via the window style
  373.     DWORD dwStyle = GetStyle();
  374.  
  375.     // Recalc the window size and position based on the text justification
  376.     if (dwStyle & SS_CENTERIMAGE)
  377.         WndRect.DeflateRect(0, (WndRect.Height() - Extent.cy)/2);
  378.     else
  379.         WndRect.bottom = WndRect.top + Extent.cy;
  380.  
  381.     if (dwStyle & SS_CENTER)   
  382.         WndRect.DeflateRect((WndRect.Width() - Extent.cx)/2, 0);
  383.     else if (dwStyle & SS_RIGHT) 
  384.         WndRect.left  = WndRect.right - Extent.cx;
  385.     else // SS_LEFT = 0, so we can't test for it explicitly 
  386.         WndRect.right = WndRect.left + Extent.cx;
  387.  
  388.     // Move the window
  389.     SetWindowPos(NULL, WndRect.left, WndRect.top, WndRect.Width(), WndRect.Height(), SWP_NOZORDER);
  390. }
  391.  
  392. /////////////////////////////////////////////////////////////////////////////
  393. // CHyperLink implementation
  394.  
  395. // The following appeared in Paul DiLascia's Jan 1998 MSJ articles.
  396. // It loads a "hand" cursor from the winhlp32.exe module
  397. void CHyperLink::SetDefaultCursor()
  398. {
  399.     if (m_hLinkCursor == NULL)                // No cursor handle - load our own
  400.     {
  401.         // Get the windows directory
  402.         CString strWndDir;
  403.         GetWindowsDirectory(strWndDir.GetBuffer(MAX_PATH), MAX_PATH);
  404.         strWndDir.ReleaseBuffer();
  405.  
  406.         strWndDir += _T("\\winhlp32.exe");
  407.         // This retrieves cursor #106 from winhlp32.exe, which is a hand pointer
  408.         HMODULE hModule = LoadLibrary(strWndDir);
  409.         if (hModule) {
  410.             HCURSOR hHandCursor = ::LoadCursor(hModule, MAKEINTRESOURCE(106));
  411.             if (hHandCursor)
  412.                 m_hLinkCursor = CopyCursor(hHandCursor);
  413.         }
  414.         FreeLibrary(hModule);
  415.     }
  416. }
  417.  
  418. LONG CHyperLink::GetRegKey(HKEY key, LPCTSTR subkey, LPTSTR retdata)
  419. {
  420.     HKEY hkey;
  421.     LONG retval = RegOpenKeyEx(key, subkey, 0, KEY_QUERY_VALUE, &hkey);
  422.  
  423.     if (retval == ERROR_SUCCESS) {
  424.         long datasize = MAX_PATH;
  425.         TCHAR data[MAX_PATH];
  426.         RegQueryValue(hkey, NULL, data, &datasize);
  427.         lstrcpy(retdata,data);
  428.         RegCloseKey(hkey);
  429.     }
  430.  
  431.     return retval;
  432. }
  433.  
  434. void CHyperLink::ReportError(int nError)
  435. {
  436.     CString str;
  437.     switch (nError) {
  438.         case 0:                       str = "The operating system is out\nof memory or resources."; break;
  439.         case SE_ERR_PNF:              str = "The specified path was not found."; break;
  440.         case SE_ERR_FNF:              str = "The specified file was not found."; break;
  441.         case ERROR_BAD_FORMAT:        str = "The .EXE file is invalid\n(non-Win32 .EXE or error in .EXE image)."; break;
  442.         case SE_ERR_ACCESSDENIED:     str = "The operating system denied\naccess to the specified file."; break;
  443.         case SE_ERR_ASSOCINCOMPLETE:  str = "The filename association is\nincomplete or invalid."; break;
  444.         case SE_ERR_DDEBUSY:          str = "The DDE transaction could not\nbe completed because other DDE transactions\nwere being processed."; break;
  445.         case SE_ERR_DDEFAIL:          str = "The DDE transaction failed."; break;
  446.         case SE_ERR_DDETIMEOUT:       str = "The DDE transaction could not\nbe completed because the request timed out."; break;
  447.         case SE_ERR_DLLNOTFOUND:      str = "The specified dynamic-link library was not found."; break;
  448.         case SE_ERR_NOASSOC:          str = "There is no application associated\nwith the given filename extension."; break;
  449.         case SE_ERR_OOM:              str = "There was not enough memory to complete the operation."; break;
  450.         case SE_ERR_SHARE:            str = "A sharing violation occurred. ";
  451.         default:                      str.Format(_T("Unknown Error (%d) occurred."), nError); break;
  452.     }
  453.     str = "Unable to open hyperlink:\n\n" + str;
  454.     AfxMessageBox(str, MB_ICONEXCLAMATION | MB_OK);
  455. }
  456.  
  457. HINSTANCE CHyperLink::GotoURL(LPCTSTR url, int showcmd)
  458. {
  459.     TCHAR key[MAX_PATH + MAX_PATH];
  460.  
  461.     // First try ShellExecute()
  462.     HINSTANCE result = ShellExecute(NULL, _T("open"), url, NULL,NULL, showcmd);
  463.  
  464.     // If it failed, get the .htm regkey and lookup the program
  465.     if ((UINT)result <= HINSTANCE_ERROR) {
  466.  
  467.         if (GetRegKey(HKEY_CLASSES_ROOT, _T(".htm"), key) == ERROR_SUCCESS) {
  468.             lstrcat(key, _T("\\shell\\open\\command"));
  469.  
  470.             if (GetRegKey(HKEY_CLASSES_ROOT,key,key) == ERROR_SUCCESS) {
  471.                 TCHAR *pos;
  472.                 pos = _tcsstr(key, _T("\"%1\""));
  473.                 if (pos == NULL) {                     // No quotes found
  474.                     pos = _tcsstr(key, _T("%1"));      // Check for %1, without quotes 
  475.                     if (pos == NULL)                   // No parameter at all...
  476.                         pos = key+lstrlen(key)-1;
  477.                     else
  478.                         *pos = '\0';                   // Remove the parameter
  479.                 }
  480.                 else
  481.                     *pos = '\0';                       // Remove the parameter
  482.  
  483.                 lstrcat(pos, _T(" "));
  484.                 lstrcat(pos, url);
  485.  
  486.                 USES_CONVERSION;
  487.                 result = (HINSTANCE) WinExec(T2A(key),showcmd);
  488.             }
  489.         }
  490.     }
  491.  
  492.     return result;
  493. }
  494.  
  495.